home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / gencodec / source / gencodecmain.c < prev    next >
C/C++ Source or Header  |  1999-01-01  |  12KB  |  484 lines
  1. /* Main-Header File inserted by GenCodeC */
  2. /* Libraries */
  3. #include <libraries/mui.h>
  4. #include <libraries/gadtools.h> /* for BARLABEL in MenuItem */
  5.  
  6. /* Prototypes */
  7. #ifdef __GNUC__
  8. #include <proto/muimaster.h>
  9. #include <proto/exec.h>
  10. #include <proto/alib.h>
  11. #include <proto/dos.h>
  12. #else
  13. #include <clib/muimaster_protos.h>
  14. #include <clib/exec_protos.h>
  15. #include <clib/alib_protos.h>
  16. #include <clib/dos_protos.h>
  17. #include <pragmas/muimaster_pragmas.h>
  18. #endif /* __GNUC__ */
  19.  
  20. /*  Ansi  */
  21. #include <stdlib.h>
  22. #include <stdio.h>
  23.  
  24. /* Increase stack size */
  25. LONG __stack=8192;
  26. /* GenCodeC header end */
  27.  
  28. /* Include generated by GenCodeC */
  29.  
  30. #include "GenCodeCGUI.h"
  31.  
  32. #include <exec/memory.h>
  33. #include <string.h>
  34.  
  35. #include "TextField.h"
  36. #include "Tools.h"
  37. #include "GenCodeC.h"
  38. #include "MB_pragmas.h"
  39. #include "MB_protos.h"
  40. #include "MB.h"
  41.  
  42. /* defines for header file */
  43. #define  HHEADER     1
  44. #define  CHEADER     2
  45. #define  MAINHEADER  3
  46.  
  47. #define  LOCALSAVE   1
  48. #define  GLOBALSAVE  2
  49.  
  50. /* Global variables */
  51. BOOL    TextFieldLocked = FALSE;
  52. BOOL    NormalEnd = FALSE;
  53.  
  54. struct ObjTextField    *TF_H_Header = NULL;
  55. struct ObjTextField    *TF_C_Header =  NULL;
  56. struct ObjTextField    *TF_Main_Header = NULL;
  57.  
  58. char     *H_Header_Text;
  59. char     *C_Header_Text;
  60. char     *Main_Header_Text;
  61.  
  62. /* Declarations for libraries (inserted by GenCodeC) */
  63. struct Library * MUIMasterBase;
  64.  
  65. struct Library * IntuitionBase = NULL;
  66. struct Library * MUIBBase      = NULL;
  67. struct Library * TextFieldBase = NULL;
  68.  
  69. /* Init() function */
  70. void init( void )
  71. {
  72.     if (!(IntuitionBase = OpenLibrary("intuition.library",36)))
  73.     {
  74.         exit(20);
  75.     }
  76.  
  77.     if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  78.     {
  79.         DisplayMsg("Can't Open MUIMaster Library\n");
  80.         CloseLibrary(IntuitionBase);
  81.         exit(20);
  82.     }
  83.  
  84.     if (!(MUIBBase = OpenLibrary("muibuilder.library", 0)))
  85.     {
  86.         DisplayMsg("Can't Open MUIBuilder Library\n");
  87.         CloseLibrary(MUIMasterBase);
  88.         CloseLibrary(IntuitionBase);
  89.         exit(20);
  90.     }
  91.  
  92.     /* exit if we cant init the Library */
  93.     if (!MB_Open())
  94.     {
  95.         DisplayMsg("Unable to Get Temporary files !\n");
  96.         CloseLibrary(MUIBBase);
  97.         CloseLibrary(MUIMasterBase);
  98.         CloseLibrary(IntuitionBase);
  99.         exit(20);
  100.     }
  101.  
  102.     if (!(TextFieldBase = OpenLibrary("gadgets/textfield.gadget", 0)))
  103.     {
  104.         DisplayMsg("Can't Open Textfield gadget\n");
  105.         MB_Close();
  106.         CloseLibrary(MUIBBase);
  107.         CloseLibrary(MUIMasterBase);
  108.         CloseLibrary(IntuitionBase);
  109.         exit(20);
  110.     }
  111. }
  112. /* GenCodeC init() end */
  113.  
  114. void UnlockTextFieldTexts(struct ObjTextField *,char *,struct ObjTextField *,char *,struct ObjTextField *,char *);
  115.  
  116. /* End() function */
  117. void end(void *ptr_void)
  118. {
  119.     struct ObjApp *app=(struct ObjApp *)ptr_void;
  120.  
  121.     MB_Close();    /* Free Memory and Close Temporary Files */
  122.  
  123.     if (app)
  124.     {
  125.         set(app->WI_C_Generation,
  126.             MUIA_Window_Open, FALSE);
  127.  
  128.         if (TextFieldLocked)
  129.             UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  130.                              TF_C_Header,C_Header_Text,
  131.                              TF_Main_Header,Main_Header_Text);
  132.  
  133.         if (TF_H_Header && TF_H_Header->textfield)
  134.             DoMethod(app->GR_H_Header, OM_REMOVE, TF_H_Header->textfield);
  135.  
  136.         if (TF_C_Header && TF_C_Header->textfield)
  137.             DoMethod(app->GR_C_Header, OM_REMOVE, TF_C_Header->textfield);
  138.  
  139.         if (TF_Main_Header && TF_Main_Header->textfield)
  140.             DoMethod(app->GR_Main_Header, OM_REMOVE, TF_Main_Header->textfield);
  141.  
  142.         DisposeTextField(TF_H_Header);
  143.         DisposeTextField(TF_C_Header);
  144.         DisposeTextField(TF_Main_Header);
  145.  
  146.         DisposeApp(app);
  147.     }
  148.  
  149.     CloseAllFiles(!NormalEnd);
  150.     ClearMemory(!NormalEnd);
  151.  
  152.     CloseLibrary(TextFieldBase);
  153.     CloseLibrary(MUIBBase);
  154.     CloseLibrary(MUIMasterBase);
  155.     CloseLibrary(IntuitionBase);
  156.     exit(20);
  157. }
  158. /* GenCodeC end() end */
  159.  
  160. /* Read a header file and load it in memory */
  161. char *LoadHeaderFile(int HeaderFile)
  162. {
  163.     char  *TMPFile;
  164.     char  *HF;
  165.     int   size;
  166.     char  *MBDir=NULL;
  167.     char  *FileName;
  168.     
  169.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  170.     
  171.     /* Get Current Directory Name */
  172.     MBDir = GetCurrentDirectory();
  173.       
  174.     size = strlen(MBDir)+1+9+1+strlen(FilePart(FileName))+12+1;
  175.     TMPFile = AllocMemory(size,TRUE);
  176.  
  177.     /* Try to read local header and if there is no local header, try to read global header */
  178.     strcpy(TMPFile,MBDir);
  179.     AddPart(TMPFile,"C_Headers",size);
  180.     AddPart(TMPFile,FilePart(FileName),size);
  181.     remove_extend(TMPFile);
  182.     switch(HeaderFile)
  183.     {
  184.         case HHEADER:
  185.             add_extend(TMPFile,".H-Header");
  186.             break;
  187.             
  188.         case CHEADER:
  189.             add_extend(TMPFile,".C-Header");
  190.             break;
  191.             
  192.         case MAINHEADER:
  193.             add_extend(TMPFile,".Main-Header");
  194.             break;
  195.     }
  196.     if (!(HF = LoadFileInRAM(TMPFile,FALSE)))
  197.     {
  198.         FreeMemory(TMPFile);
  199.         size = strlen(MBDir)+1+9+1+12+1;
  200.         TMPFile = AllocMemory(size,FALSE);
  201.  
  202.         strcpy(TMPFile,MBDir);
  203.         AddPart(TMPFile,"C_Headers",size);
  204.         switch(HeaderFile)
  205.         {
  206.             case HHEADER:
  207.                 AddPart(TMPFile,"H-Header",size);
  208.                 break;
  209.                     
  210.             case CHEADER:
  211.                 AddPart(TMPFile,"C-Header",size);
  212.                 break;
  213.                     
  214.             case MAINHEADER:
  215.                 AddPart(TMPFile,"Main-Header",size);
  216.                 break;
  217.         }
  218.         if (!(HF = LoadFileInRAM(TMPFile,FALSE)))
  219.         {
  220.             DisplayMsg("Can't open Header file !!!");
  221.         }
  222.         FreeMemory(MBDir);
  223.         FreeMemory(TMPFile);
  224.         return HF;
  225.     }
  226.     else
  227.     {
  228.         FreeMemory(MBDir);
  229.         FreeMemory(TMPFile);
  230.         return HF;
  231.     }
  232. }
  233.  
  234. /* Save a header file */
  235. void SaveHeaderFile(int HeaderFile,char *HeaderText,int PrefsSave)
  236. {
  237.     char  *TMPFile;
  238.     int   size;
  239.     char  *MBDir = NULL;
  240.     char  *FileName;
  241.     BOOL  Prefs = (PrefsSave==LOCALSAVE);
  242.     BPTR  file;
  243.     
  244.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  245.     
  246.     /* Get Current Directory Name */
  247.     MBDir = GetCurrentDirectory();
  248.       
  249.     size = strlen(MBDir)+1+9+((Prefs) ? (1+strlen(FilePart(FileName))):1)+12+1;
  250.     if (!(TMPFile = AllocMemory(size,FALSE)))
  251.     {
  252.         FreeMemory(MBDir);
  253.         DisplayMsg("Can't save Header file !!! \n");
  254.         return;
  255.     }
  256.     else
  257.     {
  258.         strcpy(TMPFile,MBDir);
  259.         AddPart(TMPFile,"C_Headers",size);
  260.         if (Prefs)
  261.         {
  262.             AddPart(TMPFile,FilePart(FileName),size);
  263.             remove_extend(TMPFile);
  264.         }
  265.         switch(HeaderFile)
  266.         {
  267.             case HHEADER:
  268.                 (Prefs) ? add_extend(TMPFile,".H-Header") : AddPart(TMPFile,"H-Header",size);
  269.                 break;
  270.             
  271.             case CHEADER:
  272.                 (Prefs) ? add_extend(TMPFile,".C-Header") : AddPart(TMPFile,"C-Header",size);
  273.                 break;
  274.             
  275.             case MAINHEADER:
  276.                 (Prefs) ? add_extend(TMPFile,".Main-Header") : AddPart(TMPFile,"Main-Header",size);
  277.                 break;
  278.         }
  279.         if (file = OpenFile(TMPFile, MODE_NEWFILE, FALSE))
  280.         {
  281.             FreeMemory(MBDir);
  282.             FreeMemory(TMPFile);
  283.             FWrite(file,HeaderText,strlen(HeaderText),1);
  284.             CloseFile(file);
  285.         }
  286.         else
  287.         {
  288.             DisplayMsg("Can't save Header file !!! \n");
  289.         }
  290.     }
  291. }
  292.  
  293. void CreateTextFieldObjects(struct ObjApp *App,
  294.                             struct ObjTextField **TF_H_Header,
  295.                             struct ObjTextField **TF_C_Header,
  296.                             struct ObjTextField **TF_Main_Header)
  297. {
  298.     char  *HeaderText;
  299.     
  300.     if (!(*TF_H_Header = CreateTextField()))
  301.     {
  302.         DisplayMsg("Can't Create Textfield object\n");
  303.         end((void *)App);
  304.     }
  305.     DoMethod(App->GR_H_Header, OM_ADDMEMBER, (*TF_H_Header)->textfield);
  306.     HeaderText = LoadHeaderFile(HHEADER);
  307.     if (HeaderText)
  308.     {
  309.         set((*TF_H_Header)->text,TEXTFIELD_Text,HeaderText);
  310.         FreeMemory(HeaderText);
  311.     }
  312.     
  313.     if (!(*TF_C_Header = CreateTextField()))
  314.     {
  315.         DisplayMsg("Can't Create Textfield object\n");
  316.         end((void *)App);
  317.     }
  318.     DoMethod(App->GR_C_Header, OM_ADDMEMBER, (*TF_C_Header)->textfield);
  319.     HeaderText = LoadHeaderFile(CHEADER);
  320.     if (HeaderText)
  321.     {
  322.         set((*TF_C_Header)->text,TEXTFIELD_Text,HeaderText);
  323.         FreeMemory(HeaderText);
  324.     }
  325.     
  326.     if (!(*TF_Main_Header = CreateTextField()))
  327.     {
  328.         DisplayMsg("Can't Create Textfield object\n");
  329.         end((void *)App);
  330.     }
  331.     DoMethod(App->GR_Main_Header, OM_ADDMEMBER, (*TF_Main_Header)->textfield);
  332.     HeaderText = LoadHeaderFile(MAINHEADER);
  333.     if (HeaderText)
  334.     {
  335.         set((*TF_Main_Header)->text,TEXTFIELD_Text,HeaderText);
  336.         FreeMemory(HeaderText);
  337.     }
  338. }
  339.  
  340. void LockTextFieldTexts(struct ObjApp *App,
  341.                         struct ObjTextField *TF_H_Header,char **H_Header_Text,
  342.                         struct ObjTextField *TF_C_Header,char **C_Header_Text,
  343.                         struct ObjTextField *TF_Main_Header,char **Main_Header_Text)
  344. {
  345.     char    *text;
  346.     ULONG    size;
  347.     
  348.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,TRUE);
  349.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,TRUE);
  350.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,TRUE);
  351.     
  352.     get(TF_H_Header->text,TEXTFIELD_Size,&size);
  353.     get(TF_H_Header->text,TEXTFIELD_Text,&text);
  354.     *H_Header_Text = AllocMemory(size+1,TRUE);
  355.     strncpy(*H_Header_Text,text,size);
  356.     (*H_Header_Text)[size]='\0';
  357.  
  358.     get(TF_C_Header->text,TEXTFIELD_Size,&size);
  359.     get(TF_C_Header->text,TEXTFIELD_Text,&text);
  360.     *C_Header_Text = AllocMemory(size+1,TRUE);
  361.     strncpy(*C_Header_Text,text,size);
  362.     (*C_Header_Text)[size]='\0';
  363.     
  364.     get(TF_Main_Header->text,TEXTFIELD_Size,&size);
  365.     get(TF_Main_Header->text,TEXTFIELD_Text,&text);
  366.     *Main_Header_Text = AllocMemory(size+1,TRUE);
  367.     strncpy(*Main_Header_Text,text,size);
  368.     (*Main_Header_Text)[size]='\0';
  369.  
  370.     TextFieldLocked = TRUE;
  371. }
  372.  
  373. void UnlockTextFieldTexts(struct ObjTextField *TF_H_Header,char *H_Header_Text,
  374.                             struct ObjTextField *TF_C_Header,char *C_Header_Text,
  375.                             struct ObjTextField *TF_Main_Header,char *Main_Header_Text)
  376. {
  377.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,FALSE);
  378.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,FALSE);
  379.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,FALSE);
  380.  
  381.     FreeMemory(H_Header_Text);
  382.     FreeMemory(C_Header_Text);
  383.     FreeMemory(Main_Header_Text);
  384.  
  385.     TextFieldLocked = FALSE;
  386. }
  387.  
  388. /* Main Function inserted by GenCodeC */
  389. int main(int argc,char **argv)
  390. {
  391.     struct ObjApp    *App = NULL; /* Object */
  392.     BOOL            running = TRUE;
  393.     ULONG            signal;
  394.     BOOL            Locale;
  395.  
  396.     /* Program initialisation : generated by GenCodeC */
  397.     init();
  398.     
  399.     /* Create Object : generated by GenCodeC */
  400.     if (!(App = CreateApp()))
  401.     {
  402.         DisplayMsg("Can't Create App\n");
  403.         end((void *)App);
  404.     }
  405.  
  406.     SetDataQuit((void *)App);
  407.     SetFunctionQuit(end);    
  408.  
  409.     CreateTextFieldObjects(App,&TF_H_Header,&TF_C_Header,&TF_Main_Header);
  410.     
  411.     MB_Get(MUIB_Locale,&Locale,TAG_DONE);
  412.     if (!Locale)
  413.         set(App->GR_Catalog,MUIA_ShowMe,FALSE);
  414.     
  415.     set(App->WI_C_Generation,
  416.         MUIA_Window_Open, TRUE
  417.         );
  418.     
  419.     while (running)
  420.     {
  421.         switch (DoMethod(App->App,MUIM_Application_Input,&signal))
  422.         {
  423.             case MUIV_Application_ReturnID_Quit:
  424.             running = FALSE;
  425.             break;
  426.             
  427.             /* Insert your code between the "case" statement and comment "end of case ..." */
  428.             case ID_BT_SAVE_LOCAL:
  429.             {
  430.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  431.                                        TF_C_Header,&C_Header_Text,
  432.                                        TF_Main_Header,&Main_Header_Text);
  433.                     
  434.                 SaveHeaderFile(HHEADER,H_Header_Text,LOCALSAVE);
  435.                 SaveHeaderFile(CHEADER,C_Header_Text,LOCALSAVE);
  436.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,LOCALSAVE);
  437.                     
  438.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  439.                                      TF_C_Header,C_Header_Text,
  440.                                      TF_Main_Header,Main_Header_Text);
  441.             }
  442.             break;
  443.             /* end of case ID_BT_SAVE_LOCAL */
  444.  
  445.             case ID_BT_SAVE_GLOBAL:
  446.             {
  447.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  448.                                        TF_C_Header,&C_Header_Text,
  449.                                        TF_Main_Header,&Main_Header_Text);
  450.                     
  451.                 SaveHeaderFile(HHEADER,H_Header_Text,GLOBALSAVE);
  452.                 SaveHeaderFile(CHEADER,C_Header_Text,GLOBALSAVE);
  453.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,GLOBALSAVE);
  454.  
  455.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  456.                                      TF_C_Header,C_Header_Text,
  457.                                      TF_Main_Header,Main_Header_Text);
  458.             }
  459.             break;
  460.             /* end of case ID_BT_SAVE_GLOBAL */
  461.  
  462.             case ID_BT_GENERATE:
  463.             {
  464.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  465.                                        TF_C_Header,&C_Header_Text,
  466.                                        TF_Main_Header,&Main_Header_Text);
  467.  
  468.                 GenerateCode(App,H_Header_Text,C_Header_Text,Main_Header_Text);
  469.  
  470.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  471.                                      TF_C_Header,C_Header_Text,
  472.                                      TF_Main_Header,Main_Header_Text);
  473.             }
  474.             break;
  475.             /* end of case ID_BT_GENERATE */
  476.  
  477.             /* End computing of IDCMP */
  478.         }
  479.         if (running && signal) Wait(signal);
  480.     }
  481.     NormalEnd = TRUE;
  482.     end((void *)App);
  483. }
  484.